package leetcode.editor.cn;
//给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。 
//
// 如果反转后整数超过 32 位的有符号整数的范围 [−2³¹, 231 − 1] ，就返回 0。 
//假设环境不允许存储 64 位整数（有符号或无符号）。
//
// 
//
// 示例 1： 
//
// 
//输入：x = 123
//输出：321
// 
//
// 示例 2： 
//
// 
//输入：x = -123
//输出：-321
// 
//
// 示例 3： 
//
// 
//输入：x = 120
//输出：21
// 
//
// 示例 4： 
//
// 
//输入：x = 0
//输出：0
// 
//
// 
//
// 提示： 
//
// 
// -2³¹ <= x <= 2³¹ - 1 
// 
//
// Related Topics 数学 👍 3947 👎 0


//leetcode submit region begin(Prohibit modification and deletion)
class Solution253 {

        public int reverse(int x) {
            int ans = 0;
            while (x != 0) {
                // 获取个位数
                int pop = x % 10;
                // 直接乘十就超出最大值了，或者不超出但是个位数超出
                // Integer.MAX_VALUE为2147483647
                if (ans > Integer.MAX_VALUE / 10 || (ans == Integer.MAX_VALUE / 10 && pop > 7))
                    return 0;
                // 直接乘十就超出最小值了，或者不超出但是个位数超出
                // Integer.MIN_VALUE为-2147483648
                if (ans < Integer.MIN_VALUE / 10 || (ans == Integer.MIN_VALUE / 10 && pop < -8))
                    return 0;
                // 反转
                ans = ans * 10 + pop;
                x /= 10;
            }
            return ans;
        }


    public int reverse4(int x) {
        long y = x;
        if (y == 0) return 0;
        StringBuilder sb = new StringBuilder();
        if (y < 0) {
            sb.append('-');
            y *= -1;
        }
        while (y != 0) {
            sb.append(y % 10);
            y /= 10;
        }
        long l = Long.parseLong(sb.toString());
        return l > Integer.MAX_VALUE || l < Integer.MIN_VALUE ? 0 : (int) l;
    }


    public int reverse2(int x) {
        String s = String.valueOf(x);
        String reverse = reverse(s);
        long l = Long.parseLong(reverse);
        return l > Integer.MAX_VALUE || l < Integer.MIN_VALUE ? 0 : (int) l;
    }

    private String reverse(String s) {
        char[] chars = s.toCharArray();
        int i = 0;
        int j = s.length() - 1;
        if (!Character.isDigit(chars[0])) {
            i++;
        }
        while (i < j) {
            char c = chars[i];
            chars[i] = chars[j];
            chars[j] = c;
            i++;
            j--;
        }
        return new String(chars);
    }

    public int reverse1(int x) {
        String s = String.valueOf(x);
        // 是不是负数
        boolean flag = false;
        if (!Character.isDigit(s.charAt(0))) {
            flag = true;
            s = s.substring(1);
        }
        String reverse = reverse1(s);
        long l = Long.parseLong(reverse);
        if (flag) l *= -1;
        return l > Integer.MAX_VALUE || l < Integer.MIN_VALUE ? 0 : (int) l;
    }

    private String reverse1(String s) {
        char[] chars = s.toCharArray();
        int i = 0;
        int j = s.length() - 1;
        while (i < j) {
            char c = chars[i];
            chars[i] = chars[j];
            chars[j] = c;
            i++;
            j--;
        }
        return new String(chars);
    }

    public static void main(String[] args) {
        Solution253 s = new Solution253();
        System.out.println(s.reverse(-2147483648));
    }
}
//leetcode submit region end(Prohibit modification and deletion)
